/*
    * Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved.
    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    *
    * This code is free software; you can redistribute it and/or modify it
    * under the terms of the GNU General Public License version 2 only, as
    * published by the Free Software Foundation.  Oracle designates this
    * particular file as subject to the "Classpath" exception as provided
    * by Oracle in the LICENSE file that accompanied this code.
   *
   * This code is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  
  package javax.swing.tree;
  
  import java.beans.PropertyChangeListener;
  import java.io.*;
  import java.util.ArrayList;
  import java.util.BitSet;
  import java.util.Enumeration;
  import java.util.EventListener;
  import java.util.Hashtable;
  import java.util.List;
  import java.util.Vector;
  import javax.swing.event.*;
  import javax.swing.DefaultListSelectionModel;
  
  /**
   * Default implementation of TreeSelectionModel.  Listeners are notified
   * whenever
   * the paths in the selection change, not the rows. In order
   * to be able to track row changes you may wish to become a listener
   * for expansion events on the tree and test for changes from there.
   * <p>resetRowSelection is called from any of the methods that update
   * the selected paths. If you subclass any of these methods to
   * filter what is allowed to be selected, be sure and message
   * <code>resetRowSelection</code> if you do not message super.
   *
   * <strong>Warning:</strong>
   * Serialized objects of this class will not be compatible with
   * future Swing releases. The current serialization support is
   * appropriate for short term storage or RMI between applications running
   * the same version of Swing.  As of 1.4, support for long term storage
   * of all JavaBeans<sup><font size="-2">TM</font></sup>
   * has been added to the <code>java.beans</code> package.
   * Please see {@link java.beans.XMLEncoder}.
   *
   * @see javax.swing.JTree
   *
   * @author Scott Violet
   */
  public class DefaultTreeSelectionModel implements Cloneable, Serializable, TreeSelectionModel
  {
      /** Property name for selectionMode. */
      public static final String          SELECTION_MODE_PROPERTY = "selectionMode";
  
      /** Used to messaged registered listeners. */
      protected SwingPropertyChangeSupport     changeSupport;
  
      /** Paths that are currently selected.  Will be null if nothing is
        * currently selected. */
      protected TreePath[]                selection;
  
      /** Event listener list. */
      protected EventListenerList   listenerList = new EventListenerList();
  
      /** Provides a row for a given path. */
      transient protected RowMapper               rowMapper;
  
      /** Handles maintaining the list selection model. The RowMapper is used
       * to map from a TreePath to a row, and the value is then placed here. */
      protected DefaultListSelectionModel     listSelectionModel;
  
      /** Mode for the selection, will be either SINGLE_TREE_SELECTION,
       * CONTIGUOUS_TREE_SELECTION or DISCONTIGUOUS_TREE_SELECTION.
       */
      protected int                           selectionMode;
  
      /** Last path that was added. */
      protected TreePath                      leadPath;
      /** Index of the lead path in selection. */
      protected int                           leadIndex;
      /** Lead row. */
      protected int                           leadRow;
  
      /** Used to make sure the paths are unique, will contain all the paths
       * in <code>selection</code>.
      */
     private Hashtable<TreePath, Boolean>    uniquePaths;
     private Hashtable<TreePath, Boolean>    lastPaths;
     private TreePath[]                      tempPaths;
 
 
     /**
      * Creates a new instance of DefaultTreeSelectionModel that is
      * empty, with a selection mode of DISCONTIGUOUS_TREE_SELECTION.
      */
     public DefaultTreeSelectionModel() {
         listSelectionModel = new DefaultListSelectionModel();
         selectionMode = DISCONTIGUOUS_TREE_SELECTION;
         leadIndex = leadRow = -1;
         uniquePaths = new Hashtable<TreePath, Boolean>();
         lastPaths = new Hashtable<TreePath, Boolean>();
         tempPaths = new TreePath[1];
     }
 
     /**
      * Sets the RowMapper instance. This instance is used to determine
      * the row for a particular TreePath.
      */
     public void setRowMapper(RowMapper newMapper) {
         rowMapper = newMapper;
         resetRowSelection();
     }
 
     /**
      * Returns the RowMapper instance that is able to map a TreePath to a
      * row.
      */
     public RowMapper getRowMapper() {
         return rowMapper;
     }
 
     /**
      * Sets the selection model, which must be one of SINGLE_TREE_SELECTION,
      * CONTIGUOUS_TREE_SELECTION or DISCONTIGUOUS_TREE_SELECTION. If mode
      * is not one of the defined value,
      * <code>DISCONTIGUOUS_TREE_SELECTION</code> is assumed.
      * <p>This may change the selection if the current selection is not valid
      * for the new mode. For example, if three TreePaths are
      * selected when the mode is changed to <code>SINGLE_TREE_SELECTION</code>,
      * only one TreePath will remain selected. It is up to the particular
      * implementation to decide what TreePath remains selected.
      * <p>
      * Setting the mode to something other than the defined types will
      * result in the mode becoming <code>DISCONTIGUOUS_TREE_SELECTION</code>.
      */
     public void setSelectionMode(int mode) {
         int            oldMode = selectionMode;
 
         selectionMode = mode;
         if(selectionMode != TreeSelectionModel.SINGLE_TREE_SELECTION &&
            selectionMode != TreeSelectionModel.CONTIGUOUS_TREE_SELECTION &&
            selectionMode != TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION)
             selectionMode = TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION;
         if(oldMode != selectionMode && changeSupport != null)
             changeSupport.firePropertyChange(SELECTION_MODE_PROPERTY,
                                              Integer.valueOf(oldMode),
                                              Integer.valueOf(selectionMode));
     }
 
     /**
      * Returns the selection mode, one of <code>SINGLE_TREE_SELECTION</code>,
      * <code>DISCONTIGUOUS_TREE_SELECTION</code> or
      * <code>CONTIGUOUS_TREE_SELECTION</code>.
      */
     public int getSelectionMode() {
         return selectionMode;
     }
 
     /**
       * Sets the selection to path. If this represents a change, then
       * the TreeSelectionListeners are notified. If <code>path</code> is
       * null, this has the same effect as invoking <code>clearSelection</code>.
       *
       * @param path new path to select
       */
     public void setSelectionPath(TreePath path) {
         if(path == null)
             setSelectionPaths(null);
         else {
             TreePath[]          newPaths = new TreePath[1];
 
             newPaths[0] = path;
             setSelectionPaths(newPaths);
         }
     }
 
     /**
      * Sets the selection. Whether the supplied paths are taken as the
      * new selection depends upon the selection mode. If the supplied
      * array is {@code null}, or empty, the selection is cleared. If
      * the selection mode is {@code SINGLE_TREE_SELECTION}, only the
      * first path in {@code pPaths} is used. If the selection
      * mode is {@code CONTIGUOUS_TREE_SELECTION} and the supplied paths
      * are not contiguous, then only the first path in {@code pPaths} is
      * used. If the selection mode is
      * {@code DISCONTIGUOUS_TREE_SELECTION}, then all paths are used.
      * <p>
      * All {@code null} paths in {@code pPaths} are ignored.
      * <p>
      * If this represents a change, all registered {@code
      * TreeSelectionListener}s are notified.
      * <p>
      * The lead path is set to the last unique path.
      * <p>
      * The paths returned from {@code getSelectionPaths} are in the same
      * order as those supplied to this method.
      *
      * @param pPaths the new selection
      */
     public void setSelectionPaths(TreePath[] pPaths) {
         int            newCount, newCounter, oldCount, oldCounter;
         TreePath[]     paths = pPaths;
 
         if(paths == null)
             newCount = 0;
         else
             newCount = paths.length;
         if(selection == null)
             oldCount = 0;
         else
             oldCount = selection.length;
         if((newCount + oldCount) != 0) {
             if(selectionMode == TreeSelectionModel.SINGLE_TREE_SELECTION) {
                 /* If single selection and more than one path, only allow
                    first. */
                 if(newCount > 1) {
                     paths = new TreePath[1];
                     paths[0] = pPaths[0];
                     newCount = 1;
                 }
             }
             else if(selectionMode ==
                     TreeSelectionModel.CONTIGUOUS_TREE_SELECTION) {
                 /* If contiguous selection and paths aren't contiguous,
                    only select the first path item. */
                 if(newCount > 0 && !arePathsContiguous(paths)) {
                     paths = new TreePath[1];
                     paths[0] = pPaths[0];
                     newCount = 1;
                 }
             }
 
             TreePath         beginLeadPath = leadPath;
             Vector<PathPlaceHolder> cPaths = new Vector<PathPlaceHolder>(newCount + oldCount);
             List<TreePath> newSelectionAsList =
                     new ArrayList<TreePath>(newCount);
 
             lastPaths.clear();
             leadPath = null;
             /* Find the paths that are new. */
             for(newCounter = 0; newCounter < newCount; newCounter++) {
                 TreePath path = paths[newCounter];
                 if (path != null && lastPaths.get(path) == null) {
                     lastPaths.put(path, Boolean.TRUE);
                     if (uniquePaths.get(path) == null) {
                         cPaths.addElement(new PathPlaceHolder(path, true));
                     }
                     leadPath = path;
                     newSelectionAsList.add(path);
                 }
             }
 
             TreePath[] newSelection = newSelectionAsList.toArray(
                     new TreePath[newSelectionAsList.size()]);
 
             /* Get the paths that were selected but no longer selected. */
             for(oldCounter = 0; oldCounter < oldCount; oldCounter++)
                 if(selection[oldCounter] != null &&
                     lastPaths.get(selection[oldCounter]) == null)
                     cPaths.addElement(new PathPlaceHolder
                                       (selection[oldCounter], false));
 
             selection = newSelection;
 
             Hashtable<TreePath, Boolean>  tempHT = uniquePaths;
 
             uniquePaths = lastPaths;
             lastPaths = tempHT;
             lastPaths.clear();
 
             // No reason to do this now, but will still call it.
             insureUniqueness();
 
             updateLeadIndex();
 
             resetRowSelection();
             /* Notify of the change. */
             if(cPaths.size() > 0)
                 notifyPathChange(cPaths, beginLeadPath);
         }
     }
 
     /**
       * Adds path to the current selection. If path is not currently
       * in the selection the TreeSelectionListeners are notified. This has
       * no effect if <code>path</code> is null.
       *
       * @param path the new path to add to the current selection
       */
     public void addSelectionPath(TreePath path) {
         if(path != null) {
             TreePath[]            toAdd = new TreePath[1];
 
             toAdd[0] = path;
             addSelectionPaths(toAdd);
         }
     }
 
     /**
       * Adds paths to the current selection. If any of the paths in
       * paths are not currently in the selection the TreeSelectionListeners
       * are notified. This has
       * no effect if <code>paths</code> is null.
       * <p>The lead path is set to the last element in <code>paths</code>.
       * <p>If the selection mode is <code>CONTIGUOUS_TREE_SELECTION</code>,
       * and adding the new paths would make the selection discontiguous.
       * Then two things can result: if the TreePaths in <code>paths</code>
       * are contiguous, then the selection becomes these TreePaths,
       * otherwise the TreePaths aren't contiguous and the selection becomes
       * the first TreePath in <code>paths</code>.
       *
       * @param paths the new path to add to the current selection
       */
     public void addSelectionPaths(TreePath[] paths) {
         int       newPathLength = ((paths == null) ? 0 : paths.length);
 
         if(newPathLength > 0) {
             if(selectionMode == TreeSelectionModel.SINGLE_TREE_SELECTION) {
                 setSelectionPaths(paths);
             }
             else if(selectionMode == TreeSelectionModel.
                     CONTIGUOUS_TREE_SELECTION && !canPathsBeAdded(paths)) {
                 if(arePathsContiguous(paths)) {
                     setSelectionPaths(paths);
                 }
                 else {
                     TreePath[]          newPaths = new TreePath[1];
 
                     newPaths[0] = paths[0];
                     setSelectionPaths(newPaths);
                 }
             }
             else {
                 int               counter, validCount;
                 int               oldCount;
                 TreePath          beginLeadPath = leadPath;
                 Vector<PathPlaceHolder>  cPaths = null;
 
                 if(selection == null)
                     oldCount = 0;
                 else
                     oldCount = selection.length;
                 /* Determine the paths that aren't currently in the
                    selection. */
                 lastPaths.clear();
                 for(counter = 0, validCount = 0; counter < newPathLength;
                     counter++) {
                     if(paths[counter] != null) {
                         if (uniquePaths.get(paths[counter]) == null) {
                             validCount++;
                             if(cPaths == null)
                                 cPaths = new Vector<PathPlaceHolder>();
                             cPaths.addElement(new PathPlaceHolder
                                               (paths[counter], true));
                             uniquePaths.put(paths[counter], Boolean.TRUE);
                             lastPaths.put(paths[counter], Boolean.TRUE);
                         }
                         leadPath = paths[counter];
                     }
                 }
 
                 if(leadPath == null) {
                     leadPath = beginLeadPath;
                 }
 
                 if(validCount > 0) {
                     TreePath         newSelection[] = new TreePath[oldCount +
                                                                   validCount];
 
                     /* And build the new selection. */
                     if(oldCount > 0)
                         System.arraycopy(selection, 0, newSelection, 0,
                                          oldCount);
                     if(validCount != paths.length) {
                         /* Some of the paths in paths are already in
                            the selection. */
                         Enumeration<TreePath> newPaths = lastPaths.keys();
 
                         counter = oldCount;
                         while (newPaths.hasMoreElements()) {
                             newSelection[counter++] = newPaths.nextElement();
                         }
                     }
                     else {
                         System.arraycopy(paths, 0, newSelection, oldCount,
                                          validCount);
                     }
 
                     selection = newSelection;
 
                     insureUniqueness();
 
                     updateLeadIndex();
 
                     resetRowSelection();
 
                     notifyPathChange(cPaths, beginLeadPath);
                 }
                 else
                     leadPath = beginLeadPath;
                 lastPaths.clear();
             }
         }
     }
 
     /**
       * Removes path from the selection. If path is in the selection
       * The TreeSelectionListeners are notified. This has no effect if
       * <code>path</code> is null.
       *
       * @param path the path to remove from the selection
       */
     public void removeSelectionPath(TreePath path) {
         if(path != null) {
             TreePath[]             rPath = new TreePath[1];
 
             rPath[0] = path;
             removeSelectionPaths(rPath);
         }
     }
 
     /**
       * Removes paths from the selection.  If any of the paths in paths
       * are in the selection the TreeSelectionListeners are notified.
       * This has no effect if <code>paths</code> is null.
       *
       * @param paths the paths to remove from the selection
       */
     public void removeSelectionPaths(TreePath[] paths) {
         if (paths != null && selection != null && paths.length > 0) {
             if(!canPathsBeRemoved(paths)) {
                 /* Could probably do something more interesting here! */
                 clearSelection();
             }
             else {
                 Vector<PathPlaceHolder> pathsToRemove = null;
 
                 /* Find the paths that can be removed. */
                 for (int removeCounter = paths.length - 1; removeCounter >= 0;
                      removeCounter--) {
                     if(paths[removeCounter] != null) {
                         if (uniquePaths.get(paths[removeCounter]) != null) {
                             if(pathsToRemove == null)
                                 pathsToRemove = new Vector<PathPlaceHolder>(paths.length);
                             uniquePaths.remove(paths[removeCounter]);
                             pathsToRemove.addElement(new PathPlaceHolder
                                          (paths[removeCounter], false));
                         }
                     }
                 }
                 if(pathsToRemove != null) {
                     int         removeCount = pathsToRemove.size();
                     TreePath    beginLeadPath = leadPath;
 
                     if(removeCount == selection.length) {
                         selection = null;
                     }
                     else {
                         Enumeration<TreePath> pEnum = uniquePaths.keys();
                         int                  validCount = 0;
 
                         selection = new TreePath[selection.length -
                                                 removeCount];
                         while (pEnum.hasMoreElements()) {
                             selection[validCount++] = pEnum.nextElement();
                         }
                     }
                     if (leadPath != null &&
                         uniquePaths.get(leadPath) == null) {
                         if (selection != null) {
                             leadPath = selection[selection.length - 1];
                         }
                         else {
                             leadPath = null;
                         }
                     }
                     else if (selection != null) {
                         leadPath = selection[selection.length - 1];
                     }
                     else {
                         leadPath = null;
                     }
                     updateLeadIndex();
 
                     resetRowSelection();
 
                     notifyPathChange(pathsToRemove, beginLeadPath);
                 }
             }
         }
     }
 
     /**
       * Returns the first path in the selection. This is useful if there
       * if only one item currently selected.
       */
     public TreePath getSelectionPath() {
         if (selection != null && selection.length > 0) {
             return selection[0];
         }
         return null;
     }
 
     /**
       * Returns the selection.
       *
       * @return the selection
       */
     public TreePath[] getSelectionPaths() {
         if(selection != null) {
             int                 pathSize = selection.length;
             TreePath[]          result = new TreePath[pathSize];
 
             System.arraycopy(selection, 0, result, 0, pathSize);
             return result;
         }
         return new TreePath[0];
     }
 
     /**
      * Returns the number of paths that are selected.
      */
     public int getSelectionCount() {
         return (selection == null) ? 0 : selection.length;
     }
 
     /**
       * Returns true if the path, <code>path</code>,
       * is in the current selection.
       */
     public boolean isPathSelected(TreePath path) {
         return (path != null) ? (uniquePaths.get(path) != null) : false;
     }
 
     /**
       * Returns true if the selection is currently empty.
       */
     public boolean isSelectionEmpty() {
         return (selection == null || selection.length == 0);
     }
 
     /**
       * Empties the current selection.  If this represents a change in the
       * current selection, the selection listeners are notified.
       */
     public void clearSelection() {
         if (selection != null && selection.length > 0) {
             int                    selSize = selection.length;
             boolean[]              newness = new boolean[selSize];
 
             for(int counter = 0; counter < selSize; counter++)
                 newness[counter] = false;
 
             TreeSelectionEvent     event = new TreeSelectionEvent
                 (this, selection, newness, leadPath, null);
 
             leadPath = null;
             leadIndex = leadRow = -1;
             uniquePaths.clear();
             selection = null;
             resetRowSelection();
             fireValueChanged(event);
         }
     }
 
     /**
       * Adds x to the list of listeners that are notified each time the
       * set of selected TreePaths changes.
       *
       * @param x the new listener to be added
       */
     public void addTreeSelectionListener(TreeSelectionListener x) {
         listenerList.add(TreeSelectionListener.class, x);
     }
 
     /**
       * Removes x from the list of listeners that are notified each time
       * the set of selected TreePaths changes.
       *
       * @param x the listener to remove
       */
     public void removeTreeSelectionListener(TreeSelectionListener x) {
         listenerList.remove(TreeSelectionListener.class, x);
     }
 
     /**
      * Returns an array of all the tree selection listeners
      * registered on this model.
      *
      * @return all of this model's <code>TreeSelectionListener</code>s
      *         or an empty
      *         array if no tree selection listeners are currently registered
      *
      * @see #addTreeSelectionListener
      * @see #removeTreeSelectionListener
      *
      * @since 1.4
      */
     public TreeSelectionListener[] getTreeSelectionListeners() {
         return listenerList.getListeners(TreeSelectionListener.class);
     }
 
     /**
      * Notifies all listeners that are registered for
      * tree selection events on this object.
      * @see #addTreeSelectionListener
      * @see EventListenerList
      */
     protected void fireValueChanged(TreeSelectionEvent e) {
         // Guaranteed to return a non-null array
         Object[] listeners = listenerList.getListenerList();
         // TreeSelectionEvent e = null;
         // Process the listeners last to first, notifying
         // those that are interested in this event
         for (int i = listeners.length-2; i>=0; i-=2) {
             if (listeners[i]==TreeSelectionListener.class) {
                 // Lazily create the event:
                 // if (e == null)
                 // e = new ListSelectionEvent(this, firstIndex, lastIndex);
                 ((TreeSelectionListener)listeners[i+1]).valueChanged(e);
             }
         }
     }
 
     /**
      * Returns an array of all the objects currently registered
      * as <code><em>Foo</em>Listener</code>s
      * upon this model.
      * <code><em>Foo</em>Listener</code>s are registered using the
      * <code>add<em>Foo</em>Listener</code> method.
      *
      * <p>
      *
      * You can specify the <code>listenerType</code> argument
      * with a class literal,
      * such as
      * <code><em>Foo</em>Listener.class</code>.
      * For example, you can query a
      * <code>DefaultTreeSelectionModel</code> <code>m</code>
      * for its tree selection listeners with the following code:
      *
      * <pre>TreeSelectionListener[] tsls = (TreeSelectionListener[])(m.getListeners(TreeSelectionListener.class));</pre>
      *
      * If no such listeners exist, this method returns an empty array.
      *
      * @param listenerType the type of listeners requested; this parameter
      *          should specify an interface that descends from
      *          <code>java.util.EventListener</code>
      * @return an array of all objects registered as
      *          <code><em>Foo</em>Listener</code>s on this component,
      *          or an empty array if no such
      *          listeners have been added
      * @exception ClassCastException if <code>listenerType</code>
      *          doesn't specify a class or interface that implements
      *          <code>java.util.EventListener</code>
      *
      * @see #getTreeSelectionListeners
      * @see #getPropertyChangeListeners
      *
      * @since 1.3
      */
     public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
         return listenerList.getListeners(listenerType);
     }
 
     /**
      * Returns the selection in terms of rows. There is not
      * necessarily a one-to-one mapping between the {@code TreePath}s
      * returned from {@code getSelectionPaths} and this method. In
      * particular, if a {@code TreePath} is not viewable (the {@code
      * RowMapper} returns {@code -1} for the row corresponding to the
      * {@code TreePath}), then the corresponding row is not included
      * in the returned array. For example, if the selection consists
      * of two paths, {@code A} and {@code B}, with {@code A} at row
      * {@code 10}, and {@code B} not currently viewable, then this method
      * returns an array with the single entry {@code 10}.
      *
      * @return the selection in terms of rows
      */
     public int[] getSelectionRows() {
         // This is currently rather expensive.  Needs
         // to be better support from ListSelectionModel to speed this up.
         if (rowMapper != null && selection != null && selection.length > 0) {
             int[]      rows = rowMapper.getRowsForPaths(selection);
 
             if (rows != null) {
                 int       invisCount = 0;
 
                 for (int counter = rows.length - 1; counter >= 0; counter--) {
                     if (rows[counter] == -1) {
                         invisCount++;
                     }
                 }
                 if (invisCount > 0) {
                     if (invisCount == rows.length) {
                         rows = null;
                     }
                     else {
                         int[]    tempRows = new int[rows.length - invisCount];
 
                         for (int counter = rows.length - 1, visCounter = 0;
                              counter >= 0; counter--) {
                             if (rows[counter] != -1) {
                                 tempRows[visCounter++] = rows[counter];
                             }
                         }
                         rows = tempRows;
                     }
                 }
             }
             return rows;
         }
         return new int[0];
     }
 
     /**
      * Returns the smallest value obtained from the RowMapper for the
      * current set of selected TreePaths. If nothing is selected,
      * or there is no RowMapper, this will return -1.
       */
     public int getMinSelectionRow() {
         return listSelectionModel.getMinSelectionIndex();
     }
 
     /**
      * Returns the largest value obtained from the RowMapper for the
      * current set of selected TreePaths. If nothing is selected,
      * or there is no RowMapper, this will return -1.
       */
     public int getMaxSelectionRow() {
         return listSelectionModel.getMaxSelectionIndex();
     }
 
     /**
       * Returns true if the row identified by <code>row</code> is selected.
       */
     public boolean isRowSelected(int row) {
         return listSelectionModel.isSelectedIndex(row);
     }
 
     /**
      * Updates this object's mapping from TreePath to rows. This should
      * be invoked when the mapping from TreePaths to integers has changed
      * (for example, a node has been expanded).
      * <p>You do not normally have to call this, JTree and its associated
      * Listeners will invoke this for you. If you are implementing your own
      * View class, then you will have to invoke this.
      * <p>This will invoke <code>insureRowContinuity</code> to make sure
      * the currently selected TreePaths are still valid based on the
      * selection mode.
      */
     public void resetRowSelection() {
         listSelectionModel.clearSelection();
         if(selection != null && rowMapper != null) {
             int               aRow;
             int               validCount = 0;
             int[]             rows = rowMapper.getRowsForPaths(selection);
 
             for(int counter = 0, maxCounter = selection.length;
                 counter < maxCounter; counter++) {
                 aRow = rows[counter];
                 if(aRow != -1) {
                     listSelectionModel.addSelectionInterval(aRow, aRow);
                 }
             }
             if(leadIndex != -1 && rows != null) {
                 leadRow = rows[leadIndex];
             }
             else if (leadPath != null) {
                 // Lead selection path doesn't have to be in the selection.
                 tempPaths[0] = leadPath;
                 rows = rowMapper.getRowsForPaths(tempPaths);
                 leadRow = (rows != null) ? rows[0] : -1;
             }
             else {
                 leadRow = -1;
             }
             insureRowContinuity();
 
         }
         else
             leadRow = -1;
     }
 
     /**
      * Returns the lead selection index. That is the last index that was
      * added.
      */
     public int getLeadSelectionRow() {
         return leadRow;
     }
 
     /**
      * Returns the last path that was added. This may differ from the
      * leadSelectionPath property maintained by the JTree.
      */
     public TreePath getLeadSelectionPath() {
         return leadPath;
     }
 
     /**
      * Adds a PropertyChangeListener to the listener list.
      * The listener is registered for all properties.
      * <p>
      * A PropertyChangeEvent will get fired when the selection mode
      * changes.
      *
      * @param listener  the PropertyChangeListener to be added
      */
     public synchronized void addPropertyChangeListener(
                                 PropertyChangeListener listener) {
         if (changeSupport == null) {
             changeSupport = new SwingPropertyChangeSupport(this);
         }
         changeSupport.addPropertyChangeListener(listener);
     }
 
     /**
      * Removes a PropertyChangeListener from the listener list.
      * This removes a PropertyChangeListener that was registered
      * for all properties.
      *
      * @param listener  the PropertyChangeListener to be removed
      */
 
     public synchronized void removePropertyChangeListener(
                                 PropertyChangeListener listener) {
         if (changeSupport == null) {
             return;
         }
         changeSupport.removePropertyChangeListener(listener);
     }
 
     /**
      * Returns an array of all the property change listeners
      * registered on this <code>DefaultTreeSelectionModel</code>.
      *
      * @return all of this model's <code>PropertyChangeListener</code>s
      *         or an empty
      *         array if no property change listeners are currently registered
      *
      * @see #addPropertyChangeListener
      * @see #removePropertyChangeListener
      *
      * @since 1.4
      */
     public PropertyChangeListener[] getPropertyChangeListeners() {
         if (changeSupport == null) {
             return new PropertyChangeListener[0];
         }
         return changeSupport.getPropertyChangeListeners();
     }
 
     /**
      * Makes sure the currently selected <code>TreePath</code>s are valid
      * for the current selection mode.
      * If the selection mode is <code>CONTIGUOUS_TREE_SELECTION</code>
      * and a <code>RowMapper</code> exists, this will make sure all
      * the rows are contiguous, that is, when sorted all the rows are
      * in order with no gaps.
      * If the selection isn't contiguous, the selection is
      * reset to contain the first set, when sorted, of contiguous rows.
      * <p>
      * If the selection mode is <code>SINGLE_TREE_SELECTION</code> and
      * more than one TreePath is selected, the selection is reset to
      * contain the first path currently selected.
      */
     protected void insureRowContinuity() {
         if(selectionMode == TreeSelectionModel.CONTIGUOUS_TREE_SELECTION &&
            selection != null && rowMapper != null) {
             DefaultListSelectionModel lModel = listSelectionModel;
             int                       min = lModel.getMinSelectionIndex();
 
             if(min != -1) {
                 for(int counter = min,
                         maxCounter = lModel.getMaxSelectionIndex();
                         counter <= maxCounter; counter++) {
                     if(!lModel.isSelectedIndex(counter)) {
                         if(counter == min) {
                             clearSelection();
                         }
                         else {
                             TreePath[] newSel = new TreePath[counter - min];
                             int selectionIndex[] = rowMapper.getRowsForPaths(selection);
                             // find the actual selection pathes corresponded to the
                             // rows of the new selection
                             for (int i = 0; i < selectionIndex.length; i++) {
                                 if (selectionIndex[i]<counter) {
                                     newSel[selectionIndex[i]-min] = selection[i];
                                 }
                             }
                             setSelectionPaths(newSel);
                             break;
                         }
                     }
                 }
             }
         }
         else if(selectionMode == TreeSelectionModel.SINGLE_TREE_SELECTION &&
                 selection != null && selection.length > 1) {
             setSelectionPath(selection[0]);
         }
     }
 
     /**
      * Returns true if the paths are contiguous,
      * or this object has no RowMapper.
      */
     protected boolean arePathsContiguous(TreePath[] paths) {
         if(rowMapper == null || paths.length < 2)
             return true;
         else {
             BitSet                             bitSet = new BitSet(32);
             int                                anIndex, counter, min;
             int                                pathCount = paths.length;
             int                                validCount = 0;
             TreePath[]                         tempPath = new TreePath[1];
 
             tempPath[0] = paths[0];
             min = rowMapper.getRowsForPaths(tempPath)[0];
             for(counter = 0; counter < pathCount; counter++) {
                 if(paths[counter] != null) {
                     tempPath[0] = paths[counter];
                     int[] rows = rowMapper.getRowsForPaths(tempPath);
                     if (rows == null) {
                         return false;
                     }
                     anIndex = rows[0];
                     if(anIndex == -1 || anIndex < (min - pathCount) ||
                        anIndex > (min + pathCount))
                         return false;
                     if(anIndex < min)
                         min = anIndex;
                     if(!bitSet.get(anIndex)) {
                         bitSet.set(anIndex);
                         validCount++;
                     }
                 }
             }
             int          maxCounter = validCount + min;
 
             for(counter = min; counter < maxCounter; counter++)
                 if(!bitSet.get(counter))
                     return false;
         }
         return true;
     }
 
     /**
      * Used to test if a particular set of <code>TreePath</code>s can
      * be added. This will return true if <code>paths</code> is null (or
      * empty), or this object has no RowMapper, or nothing is currently selected,
      * or the selection mode is <code>DISCONTIGUOUS_TREE_SELECTION</code>, or
      * adding the paths to the current selection still results in a
      * contiguous set of <code>TreePath</code>s.
      */
     protected boolean canPathsBeAdded(TreePath[] paths) {
         if(paths == null || paths.length == 0 || rowMapper == null ||
            selection == null || selectionMode ==
            TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION)
             return true;
         else {
             BitSet                       bitSet = new BitSet();
             DefaultListSelectionModel    lModel = listSelectionModel;
             int                          anIndex;
             int                          counter;
             int                          min = lModel.getMinSelectionIndex();
             int                          max = lModel.getMaxSelectionIndex();
             TreePath[]                   tempPath = new TreePath[1];
 
             if(min != -1) {
                 for(counter = min; counter <= max; counter++) {
                     if(lModel.isSelectedIndex(counter))
                         bitSet.set(counter);
                 }
             }
             else {
                 tempPath[0] = paths[0];
                 min = max = rowMapper.getRowsForPaths(tempPath)[0];
             }
             for(counter = paths.length - 1; counter >= 0; counter--) {
                 if(paths[counter] != null) {
                     tempPath[0] = paths[counter];
                     int[]   rows = rowMapper.getRowsForPaths(tempPath);
                     if (rows == null) {
                         return false;
                     }
                     anIndex = rows[0];
                     min = Math.min(anIndex, min);
                     max = Math.max(anIndex, max);
                     if(anIndex == -1)
                         return false;
                     bitSet.set(anIndex);
                 }
             }
             for(counter = min; counter <= max; counter++)
                 if(!bitSet.get(counter))
                     return false;
         }
         return true;
     }
 
     /**
      * Returns true if the paths can be removed without breaking the
      * continuity of the model.
      * This is rather expensive.
      */
     protected boolean canPathsBeRemoved(TreePath[] paths) {
         if(rowMapper == null || selection == null ||
            selectionMode == TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION)
             return true;
         else {
             BitSet               bitSet = new BitSet();
             int                  counter;
             int                  pathCount = paths.length;
             int                  anIndex;
             int                  min = -1;
             int                  validCount = 0;
             TreePath[]           tempPath = new TreePath[1];
             int[]                rows;
 
             /* Determine the rows for the removed entries. */
             lastPaths.clear();
             for (counter = 0; counter < pathCount; counter++) {
                 if (paths[counter] != null) {
                     lastPaths.put(paths[counter], Boolean.TRUE);
                 }
             }
             for(counter = selection.length - 1; counter >= 0; counter--) {
                 if(lastPaths.get(selection[counter]) == null) {
                     tempPath[0] = selection[counter];
                     rows = rowMapper.getRowsForPaths(tempPath);
                     if(rows != null && rows[0] != -1 && !bitSet.get(rows[0])) {
                         validCount++;
                         if(min == -1)
                             min = rows[0];
                         else
                             min = Math.min(min, rows[0]);
                         bitSet.set(rows[0]);
                     }
                 }
             }
             lastPaths.clear();
             /* Make sure they are contiguous. */
             if(validCount > 1) {
                 for(counter = min + validCount - 1; counter >= min;
                     counter--)
                     if(!bitSet.get(counter))
                         return false;
             }
         }
         return true;
     }
 
     /**
      * Notifies listeners of a change in path. changePaths should contain
      * instances of PathPlaceHolder.
      *
      * @deprecated As of JDK version 1.7
      */
     @Deprecated
     protected void notifyPathChange(Vector changedPaths,
                                     TreePath oldLeadSelection) {
         int                    cPathCount = changedPaths.size();
         boolean[]              newness = new boolean[cPathCount];
         TreePath[]            paths = new TreePath[cPathCount];
         PathPlaceHolder        placeholder;
 
         for(int counter = 0; counter < cPathCount; counter++) {
             placeholder = (PathPlaceHolder) changedPaths.elementAt(counter);
             newness[counter] = placeholder.isNew;
             paths[counter] = placeholder.path;
         }
 
         TreeSelectionEvent     event = new TreeSelectionEvent
                           (this, paths, newness, oldLeadSelection, leadPath);
 
         fireValueChanged(event);
     }
 
     /**
      * Updates the leadIndex instance variable.
      */
     protected void updateLeadIndex() {
         if(leadPath != null) {
             if(selection == null) {
                 leadPath = null;
                 leadIndex = leadRow = -1;
             }
             else {
                 leadRow = leadIndex = -1;
                 for(int counter = selection.length - 1; counter >= 0;
                     counter--) {
                     // Can use == here since we know leadPath came from
                     // selection
                     if(selection[counter] == leadPath) {
                         leadIndex = counter;
                         break;
                     }
                 }
             }
         }
         else {
             leadIndex = -1;
         }
     }
 
     /**
      * This method is obsolete and its implementation is now a noop.  It's
      * still called by setSelectionPaths and addSelectionPaths, but only
      * for backwards compatability.
      */
     protected void insureUniqueness() {
     }
 
 
     /**
      * Returns a string that displays and identifies this
      * object's properties.
      *
      * @return a String representation of this object
      */
     public String toString() {
         int                selCount = getSelectionCount();
         StringBuffer       retBuffer = new StringBuffer();
         int[]              rows;
 
         if(rowMapper != null)
             rows = rowMapper.getRowsForPaths(selection);
         else
             rows = null;
         retBuffer.append(getClass().getName() + " " + hashCode() + " [ ");
         for(int counter = 0; counter < selCount; counter++) {
             if(rows != null)
                 retBuffer.append(selection[counter].toString() + "@" +
                                  Integer.toString(rows[counter])+ " ");
             else
                 retBuffer.append(selection[counter].toString() + " ");
         }
         retBuffer.append("]");
         return retBuffer.toString();
     }
 
     /**
      * Returns a clone of this object with the same selection.
      * This method does not duplicate
      * selection listeners and property listeners.
      *
      * @exception CloneNotSupportedException never thrown by instances of
      *                                       this class
      */
     public Object clone() throws CloneNotSupportedException {
         DefaultTreeSelectionModel        clone = (DefaultTreeSelectionModel)
                             super.clone();
 
         clone.changeSupport = null;
         if(selection != null) {
             int              selLength = selection.length;
 
             clone.selection = new TreePath[selLength];
             System.arraycopy(selection, 0, clone.selection, 0, selLength);
         }
         clone.listenerList = new EventListenerList();
         clone.listSelectionModel = (DefaultListSelectionModel)
             listSelectionModel.clone();
         clone.uniquePaths = new Hashtable<TreePath, Boolean>();
         clone.lastPaths = new Hashtable<TreePath, Boolean>();
         clone.tempPaths = new TreePath[1];
         return clone;
     }
 
     // Serialization support.
     private void writeObject(ObjectOutputStream s) throws IOException {
         Object[]             tValues;
 
         s.defaultWriteObject();
         // Save the rowMapper, if it implements Serializable
         if(rowMapper != null && rowMapper instanceof Serializable) {
             tValues = new Object[2];
             tValues[0] = "rowMapper";
             tValues[1] = rowMapper;
         }
         else
             tValues = new Object[0];
         s.writeObject(tValues);
     }
 
 
     private void readObject(ObjectInputStream s)
         throws IOException, ClassNotFoundException {
         Object[]      tValues;
 
         s.defaultReadObject();
 
         tValues = (Object[])s.readObject();
 
         if(tValues.length > 0 && tValues[0].equals("rowMapper"))
             rowMapper = (RowMapper)tValues[1];
     }
 }
 
 /**
  * Holds a path and whether or not it is new.
  */
 class PathPlaceHolder {
     protected boolean             isNew;
     protected TreePath           path;
 
     PathPlaceHolder(TreePath path, boolean isNew) {
         this.path = path;
         this.isNew = isNew;
     }
 }